package com.fy56.platform.logistics.restful.api.utils;

import org.apache.commons.lang.StringUtils;

import java.math.BigDecimal;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 字符串转化器
 * @author 范有为
 */
public class StringToConversionUtil {
	
	/**
	 * 生成时间戳
	 * @return String
	 */
	public static String create_timestamp() {
        return Long.toString(System.currentTimeMillis() / 1000);
//        return Long.toString(new Date().getTime());
    }
	
	/**
     * 根据指定格式,将日期转为字符串
     * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
     * @param dateTime 日期
     * @return
     */
    public static String DateToString(String format, Date dateTime) {
    	if(!isNotNull(format)){
    		format="yyyy-MM-dd HH:mm:ss";
    	}
    	SimpleDateFormat sdf = new SimpleDateFormat(format);
    	return sdf.format(dateTime);
    }
    
    /**
    * 根据指定格式,将字符串转换成日期
     * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
     * @param content 内容
     * @return
     */
    public static Date StrToDate(String format, String content) {
    	if(!isNotNull(format)){
    		format="yyyy-MM-dd HH:mm:ss";
    	}
		Date date = null;
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			date = sdf.parse(content);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
    }
    
    /*-------------------------------------------------------------------*/
    
    /**
     * 根据指定的格式和内容，生成字符串
     * @param pattern 格式
     * @param arguments 内容
     */
    public static String StrFormat(String pattern, Object[] arguments){
    	return MessageFormat.format(pattern, arguments);
    }
    
    /**
     * 生成随机字符串
     * @return String
     */
    public static String create_nonce_str() {
        return UUID.randomUUID().toString();
    }
    
    /*-------------------------------------------------------------------*/
    
    /**
     * 根据集合,生成以指定字符间隔的字符串
     * @param c 集合
     * @param separator 指定字符
     * @return
     */
    public static String listToString(Collection<?> c, String separator) {
    	String val = "";
    	if(isNotNullList(c)){
    		val = StringUtils.join(c,separator);
    	}
    	return val;
    }
    
    /**
     * 根据字符串和指定字符间隔,生成的集合
     * @param content 内容
     * @param separator 指定字符
     * @return
     */
    public static List<String> stringToList(String content, String separator) {
    	List<String> list = new ArrayList<String>();
    	if(isNotNull(content)){
    		list.addAll(Arrays.asList(content.split(separator)));
    	}
    	return list;
    }
    
    /*-------------------------------------------------------------------*/
    
    /**
     * [非空验证]输入数值是否不为空and大于0
     * @param temp 输入数值
     */
    public static boolean isNumberNotNull(Number temp){
    	if(temp != null){
    		if("Integer".equals(temp.getClass().getSimpleName()) && temp.intValue()>0){
    			return true;
    		}else if("Long".equals(temp.getClass().getSimpleName()) && temp.longValue()>0L){
    			return true;
    		}else if("Short".equals(temp.getClass().getSimpleName()) && temp.shortValue()>0){
    			return true;
    		}else if("Float".equals(temp.getClass().getSimpleName()) && temp.floatValue()>0.0f){
    			return true;
    		}else if("Double".equals(temp.getClass().getSimpleName()) && temp.doubleValue()>0.0){
    			return true;
    		}else if("BigDecimal".equals(temp.getClass().getSimpleName()) && new BigDecimal(temp.toString()).compareTo(new BigDecimal("0"))>0){
    			return true;
    		}else{
    			return false;
    		}
    	}else{
    		return false;
    	}
    }
    
    /**
     * [非空验证]输入数值是否不为空and大于等于0
     * @param temp 输入数值
     */
    public static boolean isNumberNotNull2(Number temp){
    	if(temp != null){
    		if("Integer".equals(temp.getClass().getSimpleName()) && temp.intValue()>=0){
    			return true;
    		}else if("Long".equals(temp.getClass().getSimpleName()) && temp.longValue()>=0L){
    			return true;
    		}else if("Short".equals(temp.getClass().getSimpleName()) && temp.shortValue()>=0){
    			return true;
    		}else if("Float".equals(temp.getClass().getSimpleName()) && temp.floatValue()>=0.0f){
    			return true;
    		}else if("Double".equals(temp.getClass().getSimpleName()) && temp.doubleValue()>=0.0){
    			return true;
    		}else if("BigDecimal".equals(temp.getClass().getSimpleName()) && new BigDecimal(temp.toString()).compareTo(new BigDecimal("0"))>=0){
    			return true;
    		}else{
    			return false;
    		}
    	}else{
    		return false;
    	}
    }
    
    /**
	 * [非空验证]输入对象是否不为空
	 * @param argumets 输入对象
	 */
    public static boolean isNotNull(Object... argumets) {
    	boolean boolRet = true;
        for (Object obj : argumets) {
        	if(obj == null || "".equals(obj)){
        		boolRet = false;
        		break;
            }
        }
        return boolRet;
    }
    
	/**
	 * [非空验证]集合是否不为空
	 * @param temp 输入集合
	 */
	public static boolean isNotNullList(Collection<?> temp){
		if(temp!=null && temp.size()>0){
			return true;
		}else{
			return false;
		}
	}
	
	/*-------------------------------------------------------------------*/
	
	/**
	 * [生成]一个指定位数的随机数
	 * @param num 位数
	 */
	public static String arbitrarilyRandomNum(int num){
		String val = "";
		String newNo = String.valueOf(System.currentTimeMillis());
		for(int i= 0 ; i < num; i++){
			int rand = arbitrarilyRandomNum(0, newNo.length());
			val += newNo.substring(rand, rand+1);
		}
		return val;
	}
	
	/**
	 * [生成]随机数
	 * @param min 最小数
	 * @param max 最大数
	 */
	public static int arbitrarilyRandomNum(int min, int max){
		int newNo = new Random().nextInt(max)%(max-min+1) + min;
		return newNo;
	}
	
	/*-------------------------------------------------------------------*/
	
	/**
	 * [计算]日期时间,根据指定时间数
	 * @param mode 方式[1年,2月,3日,4时,5分,6秒]
	 * @param type 计算类型[1加,2减]
	 * @param date 指定日期时间
	 * @param yearSum 指定时间数
	 */
	public static Date dateCalculate(char mode, int type, Date date, int yearSum){
		int modeVal = 0;
		switch (mode) {
		case '1':
			modeVal = Calendar.YEAR;
			break;
		case '2':
			modeVal = Calendar.MONTH;
			break;
		case '3':
			modeVal = Calendar.DATE;
			break;
		case '4':
			modeVal = Calendar.HOUR;
			break;
		case '5':
			modeVal = Calendar.MINUTE;
			break;
		case '6':
			modeVal = Calendar.SECOND;
			break;
		default:
			break;
		}
		
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);//注入指定的日期时间
		if(type==1){
			calendar.add(modeVal, yearSum);//把日期往后增加指定年数
		}else if(type==2){
			calendar.add(modeVal, -yearSum);//把日期往后增加指定年数
		}
		return calendar.getTime();
	}
	
//	/**
//	 * [计算]日期时间之间的天数差
//	 * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
//	 * @param date1 指定日期时间1
//	 * @param date2 指定日期时间2
//	 * @param isLost 是否锁定 如锁定date1为锁定日期  如date2超过date1则返回0天
//	 * @return 天数差
//	 */
//	public static int daysBetween(String format, String date1, String date2, boolean isLost){
//		Calendar cal = Calendar.getInstance();
//		long time1 = 0;
//		long time2 = 0;
//		try {
//			cal.setTime(StrToDate(format, date1));
//			time1 = cal.getTimeInMillis();
//			cal.setTime(StrToDate(format, date2));
//			time2 = cal.getTimeInMillis();
//		} catch(Exception e) {
//			e.printStackTrace();
//		}
//		long between_days=(time2-time1)/(1000*3600*24);
//		//判断是否判断锁定日期
//		if(isLost){
//			if(between_days<0){
//				between_days = 0;
//			}
//		}
//		return Integer.parseInt(String.valueOf(between_days));
//	}

	/**
	 * [计算]日期时间之间的时间数差
	 * @param mode 方式[1年,2月,3日,4时,5分,6秒]
	 * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
	 * @param date1 指定日期时间1
	 * @param date2 指定日期时间2
	 * @param isLost 是否锁定 如锁定date1为锁定日期  如date2超过date1则返回0天
	 * @return 时间差数
	 */
	public static int daysBetween(char mode, String format, String date1, String date2, boolean isLost) {
		long modeVal = 0;
		switch (mode) {
		case '1':
			modeVal = (long)1000*60*60*24*365;
			break;
		case '2':
			modeVal = (long)1000*60*60*24*30;
			break;
		case '3':
			modeVal = 1000*60*60*24;
			break;
		case '4':
			modeVal = 1000*60*60;
			break;
		case '5':
			modeVal = 1000*60;
			break;
		case '6':
			modeVal = 1000;
			break;
		default:
			break;
		}
		
		Calendar cal = Calendar.getInstance();
		long time1 = 0;
		long time2 = 0;
		try{
			cal.setTime(StrToDate(format, date1));
			time1 = cal.getTimeInMillis();
			cal.setTime(StrToDate(format, date2));
			time2 = cal.getTimeInMillis();
		} catch(Exception e) {
			e.printStackTrace();
		}
		long between_days=(time1-time2)/modeVal;
		//判断是否判断锁定日期
		if(isLost){
			if(between_days<0){
				between_days = 0;
			}
		}
		return Integer.parseInt(String.valueOf(between_days));
	}
	
//	/**
//	 * [计算]日期时间之间的秒数差
//	 * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
//	 * @param date1 指定日期时间1
//	 * @param date2 指定日期时间2
//	 * @param isLost 是否锁定 如锁定date1为锁定日期  如date2超过date1则返回0天
//	 * @return 小时数差
//	 */
//	public static int daysBetween3(String format, String date1, String date2, boolean isLost) {
//		Calendar cal = Calendar.getInstance();
//		long time1 = 0;
//		long time2 = 0;
//		try{
//			cal.setTime(StrToDate(format, date1));
//			time1 = cal.getTimeInMillis();
//			cal.setTime(StrToDate(format, date2));
//			time2 = cal.getTimeInMillis();
//		} catch(Exception e) {
//			e.printStackTrace();
//		}
//		long between_days=(time2-time1)/1000;
//		//判断是否判断锁定日期
//		if(isLost){
//			if(between_days<0){
//				between_days = 0;
//			}
//		}
//		return Integer.parseInt(String.valueOf(between_days));
//	}
	
	/*-------------------------------------------------------------------*/
	
	/**
	 * [比较]日期时间的大小
	 * @param dt1 指定日期时间1
	 * @param dt2 指定日期时间2
	 * @return 1大于/0等于/-1小于
	 */
	public static int compare_date(Date dt1, Date dt2) {
		try {
			if (dt1.getTime() > dt2.getTime()) {
				return 1;
			} else if (dt1.getTime() < dt2.getTime()) {
				return -1;
			} else {
				return 0;
			}
		} catch (Exception exception) {
			exception.printStackTrace();
		}
		return 0;
	}
	
	/**
	 * [比较]日期时间的大小
	 * @param format 格式[默认：yyyy-MM-dd HH:mm:ss]
	 * @param date1 指定日期时间1
	 * @param date2 指定日期时间2
	 * @return 1大于/0等于/-1小于
	 */
	public static int compare_date(String format, String date1, String date2) {
		Date dt1 = StrToDate(format, date1);
		Date dt2 = StrToDate(format, date2);
		return compare_date(dt1, dt2);
	}

	/*-------------------------------------------------------------------*/
	
	/**
	 * 过滤特殊字符
	 * @param str
	 * @return
	 */
	public static String filterSpecialCharacters(String str){
		// 清除掉所有特殊字符 
		String regEx="[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？-]";
		String val = str.replaceAll(regEx, "");
		return val;
	}
	
	/*-------------------------------------------------------------------*/
	
	/**
	 * 根据字典序,对Map进行排序
	 * @param map
	 * @param isKeySort
	 * @return
	 */
	public static List<Map.Entry<String, String>> mapToDictionarySort(Map<String, String> map, final boolean isKeySort) {
		List<Map.Entry<String, String>> infoIds = new ArrayList<Map.Entry<String, String>>(map.entrySet());
        // 对所有传入参数按照字段名的 ASCII码从小到大排序（字典序）
        Collections.sort(infoIds, new Comparator<Map.Entry<String, String>>() {
            public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
            	if(isKeySort){
            		return (o1.getKey()).toString().compareTo(o2.getKey());
            	}else{
            		return (o1.getValue()).toString().compareTo(o2.getValue());
            	}
            }
        });
		return infoIds;
	}
	
	/**
	 * 根据字典序,对list进行排序
	 * @param list
	 */
	public static void listToDictionarySort(List<String> list) {
		Collections.sort((List<String>) list);
	}

}
